Managing Application Dependencies and External Configuration in Spring Framework

Course: Advanced Java Training

Topic: Managing Application Dependencies and External Configuration

Course Link: Advanced Java Training at JustAcademy

Demo Link: Register for a Course Demo

Website: JustAcademy Official Website

1. Introduction

Modern Java applications depend on multiple components, libraries, services, databases, and configuration values. Managing these dependencies and settings correctly is essential for building applications that are reliable, maintainable, secure, and easy to deploy across different environments.

In the Spring Framework, dependency management includes defining how objects depend on one another, allowing the Spring IoC container to create and connect those objects, and managing third-party libraries required by the application. External configuration means keeping environment-specific values outside application source code so that the same application can run in development, testing, staging, and production with different settings.

Spring supports dependency injection through constructor injection, setter injection, XML configuration, annotation-based configuration, and Java-based configuration. Spring Boot adds convenient external configuration support through properties files, YAML files, environment variables, command-line arguments, and structured configuration properties. Read the official Spring Boot external configuration documentation.

Learning Objectives

• Understand application dependencies and dependency injection.
• Learn how Spring manages objects through the IoC container.
• Understand constructor and setter injection.
• Manage dependencies using Maven or Gradle.
• Configure applications using properties and YAML files.
• Inject external values using @Value and @ConfigurationProperties.
• Use environment variables and Spring profiles for different environments.
• Apply security and troubleshooting best practices for configuration management.

2. Understanding Application Dependencies

An application dependency is any component, library, service, or resource that another component requires to perform its work. Dependencies may exist between classes inside the same application or between the application and external systems.

Types of Application Dependencies

Example of Tight Coupling

public class OrderService {
    private final OrderRepository repository = new OrderRepository();

    public void createOrder() {
        repository.save();
    }
}

In this example, OrderService creates its own repository object. It is tightly coupled to the concrete implementation, making it harder to replace the repository or test the service independently.

Improved Design Using an Interface

public interface OrderRepository {
    void save();
}

public class DatabaseOrderRepository implements OrderRepository {
    @Override
    public void save() {
        System.out.println("Order saved to database");
    }
}

public class OrderService {
    private final OrderRepository repository;

    public OrderService(OrderRepository repository) {
        this.repository = repository;
    }

    public void createOrder() {
        repository.save();
    }
}

Now, OrderService depends on an abstraction rather than directly creating a concrete repository. The required implementation can be supplied by Spring or by a test. This makes the design more flexible and easier to maintain.

3. Dependency Injection in Spring

Dependency Injection (DI) is a technique in which an object receives the dependencies it needs from an external source instead of creating those dependencies itself. Spring's IoC container is responsible for creating managed objects, resolving their dependencies, and assembling the application.

Benefits of Dependency Injection

• Loose coupling: Classes rely less on specific implementations.
• Testability: Dependencies can be replaced with mocks or test implementations.
• Maintainability: Components can be modified with fewer changes to dependent classes.
• Reusability: A dependency can be shared by multiple services where appropriate.
• Centralized management: Spring manages the creation and configuration of application beans.

Constructor Injection Example

import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

@Repository
class OrderRepositoryImpl implements OrderRepository {
    @Override
    public void save() {
        System.out.println("Order saved successfully");
    }
}

@Service
class OrderService {
    private final OrderRepository repository;

    public OrderService(OrderRepository repository) {
        this.repository = repository;
    }

    public void createOrder() {
        repository.save();
    }
}

When component scanning is enabled, Spring discovers these components and injects a suitable OrderRepository implementation into OrderService. If multiple implementations exist, a qualifier or another selection mechanism may be required.

4. Constructor Injection and Setter Injection

Spring supports multiple dependency injection approaches. Constructor injection is generally preferred for mandatory dependencies, while setter injection can be useful for optional or changeable dependencies.

Setter Injection Example

public class NotificationService {
    private MessageSender messageSender;

    public void setMessageSender(MessageSender messageSender) {
        this.messageSender = messageSender;
    }

    public void notifyUser() {
        if (messageSender == null) {
            throw new IllegalStateException("MessageSender is not configured");
        }
        messageSender.send("Welcome to our application");
    }
}

Setter injection can be configured through XML using a <property> element or through annotation-based configuration. If a dependency is mandatory, constructor injection generally communicates that requirement more clearly.

5. Managing Dependencies with Maven

Maven is a build and dependency management tool commonly used in Java applications. It downloads libraries from configured repositories, resolves transitive dependencies, and supports repeatable builds through the project's pom.xml file.

Example Maven Dependencies

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>order-management</artifactId>
    <version>1.0.0</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.2.0</version>
        </dependency>
    </dependencies>
</project>

This example demonstrates the dependency declaration structure. The version is illustrative; select a supported version that matches your project's compatibility requirements, or use a suitable Spring Boot dependency management configuration to manage versions consistently.

Important Maven Dependency Fields

Common Maven Commands

mvn clean
mvn compile
mvn test
mvn package
mvn dependency:tree

The dependency:tree command is especially useful for understanding which libraries are being included and why a particular transitive dependency is present.

6. Managing Dependencies with Gradle

Gradle is another build automation tool that supports dependency resolution, compilation, testing, and packaging. Dependencies are usually declared in a build.gradle or build.gradle.kts file.

Example Gradle Configuration

plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework:spring-context:6.2.0'
    testImplementation 'org.junit.jupiter:junit-jupiter:5.11.0'
}

test {
    useJUnitPlatform()
}

The versions above are illustrative examples rather than a recommendation to use them in every project. Select compatible versions and use a consistent dependency management strategy.

Common Gradle Commands

gradle clean
gradle build
gradle test
gradle dependencies

7. Understanding Transitive Dependencies and Version Conflicts

A transitive dependency is a library that is brought into a project because another dependency requires it. This saves developers from declaring every supporting library manually, but it can also introduce version conflicts or unexpected libraries.

Example Dependency Chain

Application
  └── Library A
      └── Library C, version 1.x
  └── Library B
      └── Library C, version 2.x

In this example, two libraries request different versions of Library C. Maven or Gradle applies its dependency resolution rules, but the selected version may not be compatible with every dependency that uses it.

Dependency Management Best Practices

• Use compatible versions of frameworks and supporting libraries.
• Use a dependency management section or platform when appropriate.
• Inspect dependency trees when unexpected behavior occurs.
• Avoid adding the same library in multiple versions without a clear reason.
• Remove unused dependencies to reduce maintenance and security risk.
• Review library updates and security advisories regularly.
• Use automated dependency scanning and testing when available.

8. What Is External Configuration?

External configuration is the practice of storing application settings outside the Java source code and changing them independently of the compiled application. This allows the same application artifact to run in different environments without rebuilding it merely to change a URL, timeout, feature flag, or other environment-specific value.

For example, a development environment might connect to a local database, while production connects to a managed database server. External configuration allows the connection settings to change without modifying the service's Java logic.

Examples of External Configuration Values

• Application name and server port.
• Database URL, username, and connection pool settings.
• External API base URLs and request timeouts.
• Logging levels and file paths.
• Feature flags and business-specific thresholds.
• Cache settings and messaging broker endpoints.

9. Configuring an Application with application.properties

Spring Boot automatically loads supported configuration files such as application.properties and application.yaml from its standard locations. A properties file stores each setting as a key-value pair.

Example application.properties

spring.application.name=order-management
server.port=8081

app.notification.enabled=true
app.notification.timeout=5000
app.notification.sender-name=OrderService

These settings demonstrate the key-value format. Spring Boot uses server.port for the embedded web server when the application uses the relevant web configuration. The custom app.notification.* properties can be read by application components.

Reading Properties with @Value

package com.example.service;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class NotificationSettings {
    private final boolean enabled;
    private final int timeout;
    private final String senderName;

    public NotificationSettings(
            @Value("${app.notification.enabled:true}") boolean enabled,
            @Value("${app.notification.timeout:3000}") int timeout,
            @Value("${app.notification.sender-name:DefaultSender}") String senderName) {
        this.enabled = enabled;
        this.timeout = timeout;
        this.senderName = senderName;
    }

    public void displaySettings() {
        System.out.println("Enabled: " + enabled);
        System.out.println("Timeout: " + timeout);
        System.out.println("Sender: " + senderName);
    }
}

The expressions use default values after the colon. If a property is absent, Spring can use the specified default rather than failing to resolve the placeholder. The actual property value is converted to the target type when supported.

10. Using YAML for External Configuration

YAML is a configuration format that represents nested data using indentation. It can make related settings easier to read, especially when an application has many grouped properties.

Example application.yml

spring:
  application:
    name: order-management

server:
  port: 8081

app:
  notification:
    enabled: true
    timeout: 5000
    sender-name: OrderService

Spring Boot can load YAML configuration when YAML support is available. Indentation is significant, so use consistent spaces and avoid tabs. For a project, it is usually simpler to use one primary configuration format consistently unless there is a specific reason to mix formats.

Properties vs YAML

11. Using @ConfigurationProperties for Type-Safe Configuration

When an application has several related settings, using @Value repeatedly can become difficult to maintain. Spring Boot provides @ConfigurationProperties to bind a group of external properties to a structured Java object.

Configuration Properties Class

package com.example.config;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "app.notification")
public class NotificationProperties {
    private boolean enabled = true;
    private int timeout = 3000;
    private String senderName = "DefaultSender";

    public boolean isEnabled() {
        return enabled;
    }

    public void setEnabled(boolean enabled) {
        this.enabled = enabled;
    }

    public int getTimeout() {
        return timeout;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }

    public String getSenderName() {
        return senderName;
    }

    public void setSenderName(String senderName) {
        this.senderName = senderName;
    }
}

Registering Configuration Properties

package com.example;

import com.example.config.NotificationProperties;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;

@SpringBootApplication
@EnableConfigurationProperties(NotificationProperties.class)
public class OrderManagementApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderManagementApplication.class, args);
    }
}

Injecting the Properties into a Service

package com.example.service;

import com.example.config.NotificationProperties;
import org.springframework.stereotype.Service;

@Service
public class NotificationService {
    private final NotificationProperties properties;

    public NotificationService(NotificationProperties properties) {
        this.properties = properties;
    }

    public void sendNotification() {
        if (!properties.isEnabled()) {
            System.out.println("Notifications are disabled.");
            return;
        }

        System.out.println("Sender: " + properties.getSenderName());
        System.out.println("Timeout: " + properties.getTimeout());
    }
}

This approach groups related settings under a common prefix and provides typed accessors. Spring Boot also supports configuration property validation when the appropriate validation dependency and constraints are configured. For larger applications, structured configuration is often easier to test and maintain than many individual property injections.

12. Accessing Properties Through the Environment Interface

Spring's Environment abstraction provides access to property sources and active profiles. It is useful when a component needs to read a property dynamically by name, although strongly typed configuration properties are usually preferable for a related group of settings.

import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

@Component
public class EnvironmentInspector {
    private final Environment environment;

    public EnvironmentInspector(Environment environment) {
        this.environment = environment;
    }

    public void displayApplicationName() {
        String appName =
            environment.getProperty("spring.application.name", "DefaultApp");

        System.out.println("Application: " + appName);
    }
}

The call to getProperty returns the configured value when available and the supplied default otherwise. The result depends on the property sources loaded into the application environment.

13. Managing Environment Variables

Environment variables allow deployment platforms and operating systems to provide settings without embedding them in source code or the packaged application. They are useful for containerized applications, cloud deployments, and CI/CD pipelines.

Example Environment Variables

SPRING_PROFILES_ACTIVE=dev
SERVER_PORT=8082
APP_NOTIFICATION_ENABLED=true
APP_NOTIFICATION_TIMEOUT=5000

Spring Boot supports relaxed binding for environment variables. For example, the property app.notification.timeout can commonly be supplied as APP_NOTIFICATION_TIMEOUT.

Benefits of Environment Variables

• Allow deployment-specific settings without changing Java source code.
• Integrate with container orchestration and deployment pipelines.
• Help separate configuration from the packaged application.
• Support different ports, URLs, and feature settings in different environments.

Environment variables are not automatically a secure secret-management system. Access to the process environment, deployment configuration, and logs should be controlled, especially when variables contain sensitive values.

14. Managing Development, Testing, and Production Profiles

Spring profiles allow an application to activate environment-specific configuration. For example, a development profile can use a local database, while a production profile uses a managed database service.

application-dev.properties

spring.datasource.url=jdbc:mysql://localhost:3306/orders_dev
spring.datasource.username=dev_user
logging.level.com.example=DEBUG

application-prod.properties

spring.datasource.url=${DB_URL}
spring.datasource.username=${DB_USERNAME}
logging.level.com.example=INFO

The production example reads connection details from external properties or environment variables. In real deployments, the password should also come from a protected secret source, not be committed to the repository.

Activating a Profile

spring.profiles.active=dev

Alternatively, a profile can be activated through a deployment environment variable or command-line argument. For example:

java -jar order-management.jar --spring.profiles.active=prod

Use profiles to select environment-specific behavior, but avoid treating a profile name as an access-control or security boundary. Production security must be enforced through proper credentials, authorization, network restrictions, and deployment controls.

15. Understanding Configuration Property Precedence

An application can receive the same property from multiple sources. Spring Boot applies a defined property-source precedence so that a higher-priority source can override a lower-priority value. This makes it possible to package safe defaults while supplying deployment-specific values externally.

For example, an application may define server.port=8081 in a properties file, but a deployment can provide a different value through an environment variable or command-line argument.

Common Configuration Sources

The exact precedence rules depend on the configuration source and Spring Boot version. Consult the official external configuration reference when resolving a conflict between values.

16. Managing Database Configuration

Database configuration typically includes the JDBC URL, username, password, driver, connection pool options, and transaction settings. These values should be separated from application logic so they can vary across environments.

Example Database Configuration

spring.datasource.url=${DB_URL}
spring.datasource.username=${DB_USERNAME}
spring.datasource.password=${DB_PASSWORD}

The example expects the relevant environment variables or equivalent property sources to be available when the application starts. Do not commit real production credentials into source control.

Database Configuration Best Practices

• Use separate database instances or schemas for development and production where appropriate.
• Use least-privilege database accounts for application access.
• Keep passwords and tokens in a managed secret store or protected deployment configuration.
• Configure connection pool limits and timeouts based on workload requirements.
• Verify database connectivity during deployment and monitor connection failures.
• Use migration tools and controlled schema changes for reliable deployments.

17. Secure Management of Sensitive Configuration

Sensitive configuration includes database passwords, API tokens, signing keys, encryption keys, and other credentials. If these values are exposed in source control, logs, build artifacts, or public repositories, unauthorized users may gain access to systems or data.

Security Best Practices

• Never commit real secrets to a public or shared source-code repository.
• Use a secret manager or protected deployment secret facility for production credentials.
• Restrict who can view or modify environment and deployment settings.
• Use different credentials for development, testing, and production.
• Rotate exposed or outdated credentials promptly.
• Avoid printing passwords, tokens, or full connection strings in application logs.
• Use encrypted transport and secure connections when supported by external services.
• Grant each application only the permissions it needs.

Externalizing a secret does not automatically make it secure. The storage location, access permissions, delivery mechanism, logging behavior, and rotation process must all be considered.

18. Common Dependency and Configuration Problems

19. Practical Project: Configurable Order Management Application

Build a small Spring Boot application that manages orders and uses external configuration for its notification behavior and database connection settings.

Project Requirements

1. Create an OrderRepository interface and an implementation for saving orders.
2. Create an OrderService that receives the repository through constructor injection.
3. Define application settings in application.properties or application.yml.
4. Create an OrderProperties class using @ConfigurationProperties.
5. Use a development profile for local testing and a production profile for deployment.
6. Read database connection details from external configuration.
7. Move sensitive values into a protected secret source.
8. Write unit tests that inject a fake or mocked repository.
9. Test application startup with missing or invalid configuration values.
10. Document the required properties and environment variables for deployment.

Example Configuration

spring.application.name=order-management
app.order.max-items=20
app.order.notifications-enabled=true
app.order.request-timeout=5000

Expected Learning Outcomes

• Application components are loosely coupled through dependency injection.
• Configuration can change without modifying Java business logic.
• Development and production settings can be maintained separately.
• Sensitive values are not hardcoded into source code.
• Dependency and configuration errors can be diagnosed systematically.

20. Interview Questions and Answers

Q1. What is an application dependency?

Answer: It is a component, library, service, or resource that an application or class needs to perform its work.

Q2. What is Dependency Injection in Spring?

Answer: Dependency Injection is a technique in which Spring supplies the dependencies required by a managed object rather than forcing the object to create those dependencies itself.

Q3. Why is constructor injection preferred for mandatory dependencies?

Answer: It makes dependencies explicit, supports final fields, and allows tests to provide dependencies directly when constructing an object.

Q4. What is external configuration?

Answer: It is the practice of keeping application settings outside the Java source code so that settings can be changed for different environments without changing the application's business logic.

Q5. What is the difference between application.properties and application.yml?

Answer: Both can hold Spring Boot configuration. Properties files use flat key-value pairs, while YAML uses indentation to represent nested structures.

Q6. What does @Value do?

Answer: It injects a literal or resolved configuration value into a bean, often from a property source, and can specify a default value in the placeholder expression.

Q7. What is @ConfigurationProperties?

Answer: It binds a group of external configuration values to a structured Java object, making related settings easier to organize and use.

Q8. What is a Spring profile?

Answer: A profile allows Spring to activate environment-specific beans or configuration, such as development and production settings.

Q9. What is a transitive dependency?

Answer: It is a dependency introduced by another library that the application uses.

Q10. How do you troubleshoot a Maven dependency conflict?

Answer: Inspect the dependency tree, identify conflicting versions, review the libraries that introduce them, and use suitable dependency management or exclusions where necessary.

Q11. Why should production credentials not be hardcoded?

Answer: Hardcoded credentials can be exposed through source control, logs, or build artifacts. Production secrets should be delivered through protected configuration or a secret-management system.

Q12. How can an environment variable override a configuration property?

Answer: Spring Boot resolves values from multiple property sources according to its precedence rules. Environment variables can override values supplied by lower-priority sources when the relevant property mapping is supported.

21. Quick Revision Checklist

• Application dependencies include classes, libraries, services, and configuration values.
• Spring's IoC container creates and manages registered beans.
• Constructor injection is generally preferred for mandatory dependencies.
• Maven and Gradle manage third-party libraries and dependency resolution.
• Transitive dependencies can introduce version conflicts.
• application.properties and application.yml hold external configuration.
• @Value injects individual configuration values.
• @ConfigurationProperties binds related settings to a structured object.
• Environment variables and profiles help adapt applications to different environments.
• Property-source precedence explains why one value may override another.
• Secrets require access controls, secure storage, and careful logging practices.
• Dependency and configuration problems should be verified through logs, build reports, and application settings.

22. Conclusion

Managing application dependencies and external configuration is a fundamental part of building professional Spring applications. Dependency injection reduces coupling and improves testability, while Maven or Gradle provides a consistent way to manage third-party libraries.

External configuration enables the same application to operate across multiple environments by using properties files, YAML, environment variables, profiles, and structured configuration classes. Combining these practices with dependency version control, secure secret management, and systematic troubleshooting helps developers build maintainable and deployment-ready Java applications.

To learn more about Java and Spring development, visit Advanced Java Training at JustAcademy, register for a course demo, or explore the JustAcademy official website.